home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / Doggie-Style Windows w_ Sound! / Source n' Stuff / Source / Patches.c < prev   
Encoding:
C/C++ Source or Header  |  2000-06-23  |  14.7 KB  |  577 lines
  1. // Doggie-Style Windows written by Mark Johns and Justin Lee
  2. // Extensive help from Mr. George Warner
  3. // Original base patch Source Code generated by PatchMaker 1.0
  4. // due to a sick idea by Paul Baxter
  5.  
  6. #if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  7.     #error Sorry Can't do that
  8. #endif
  9.  
  10. #include <MixedMode.h>
  11. #include <Appearance.h>
  12. #include <SpeechSynthesis.h>
  13. #include <LowMem.h>
  14. #include <stdlib.h>
  15. //#include <A4Stuff.h>   // Where is this?
  16.  
  17. #include "ShowInitIcon.h"
  18.  
  19. // This seems to replace A4Stuff.h
  20. #ifndef powerc
  21.  
  22. #define EnterCodeResource() long oldA4 = SetCurrentA4()
  23. #define ExitCodeResource() SetA4(oldA4)
  24. long SetCurrentA4(void);
  25. long SetA4(long:__D0):__D0 = 0xC18C;
  26. long GetCurrentA4(void) = 0x200C;
  27. pascal void UnloadA4Seg(void *);
  28.  
  29. #else
  30.  
  31. #define EnterCodeResource()
  32. #define ExitCodeResource()
  33. #define SetCurrentA4() 0L
  34. #define SetA4(x)    0L
  35. #define GetCurrentA4() 0L
  36. #define UnloadA4Seg(x) 0
  37.  
  38. #endif
  39.  
  40. // Our badass constants.
  41. #define kSwell    14
  42. #define kVOffset    7
  43. #define kHOffset    7
  44.  
  45. #define Rand(min, max) (((rand() & 0x7FFF) % ((max)-(min)+1)) + (min))
  46.  
  47. static gInMoveWindows = false;
  48.  
  49. void Swell(Rect * foo);
  50. void Initalize(void);
  51. pascal OSStatus GetWindowBounds(WindowRef window, WindowRegionCode regionCode, Rect *globalBounds);
  52. void MoveWindows(void);
  53. Boolean DoKey(int k, unsigned char gkm[16]);
  54.  
  55. static SndChannelPtr theChannel = nil;
  56. static Handle wHandle = nil;
  57. static Handle dHandle = nil;
  58.  
  59. // enums for routinedescriptor
  60. enum {
  61.     upp_MoveWindowProcInfo = kPascalStackBased
  62.         |    STACK_ROUTINE_PARAMETER(1,kFourByteCode)
  63.         |    STACK_ROUTINE_PARAMETER(2,kTwoByteCode)
  64.         |    STACK_ROUTINE_PARAMETER(3,kTwoByteCode)
  65.         |    STACK_ROUTINE_PARAMETER(4,kOneByteCode),
  66.     upp_SelectWindowProcInfo = kPascalStackBased
  67.         |    STACK_ROUTINE_PARAMETER(1,kFourByteCode),
  68.     upp_SizeWindowProcInfo = kPascalStackBased
  69.         |    STACK_ROUTINE_PARAMETER(1,kFourByteCode)
  70.         |    STACK_ROUTINE_PARAMETER(2,kTwoByteCode)
  71.         |    STACK_ROUTINE_PARAMETER(3,kTwoByteCode)
  72.         |    STACK_ROUTINE_PARAMETER(4,kOneByteCode),
  73.     uppPatcExtraInfo
  74. };
  75.  
  76. // Function Prototypes
  77. extern pascal void my_MoveWindowPatch(long param1, short param2, short param3, Boolean param4);
  78. extern pascal void my_SelectWindowPatch(long param1);
  79. extern pascal void my_SizeWindowPatch(long param1, short param2, short param3, Boolean param4);
  80.  
  81.  
  82. // Globals to hold original routine descriptors
  83. RoutineDescriptorPtr gOriginal_MoveWindow = nil;
  84. RoutineDescriptorPtr gOriginal_SelectWindow = nil;
  85. RoutineDescriptorPtr gOriginal_SizeWindow = nil;
  86.  
  87.  
  88. // Tell MetroWerks the procInfo for main
  89. ProcInfoType __procinfo =  kPascalStackBased;
  90. pascal void main(void)
  91. {
  92.     RoutineDescriptorPtr originaldesc, newdesc, unImplimentedTrapAddr;
  93.     UInt32 size;
  94.     UInt16 index;
  95.     THz theZone;
  96.     Boolean good = false;
  97.     OSErr anErr=noErr;
  98.  
  99.     // get globals
  100.     EnterCodeResource();
  101.     // detach ourselves
  102.     srand(TickCount());
  103.     DetachResource(Get1Resource('INIT', 0));
  104.  
  105.     wHandle = GetResource('snd ',128);
  106.     if (nil != wHandle)
  107.         DetachResource(wHandle);
  108.  
  109.     dHandle = GetResource('snd ',129);
  110.     if (nil != dHandle)
  111.         DetachResource(dHandle);
  112.  
  113.     // make sure we are in the system heap
  114.     theZone = GetZone();
  115.     SetZone(SystemZone());
  116.     unImplimentedTrapAddr = NGetTrapAddress(_Unimplemented, (_Unimplemented & 0x0800) ? ToolTrap : OSTrap);
  117.  
  118.     originaldesc = NGetTrapAddress(_MoveWindow, (_MoveWindow & 0x0800) ? ToolTrap : OSTrap);
  119.     if (originaldesc != unImplimentedTrapAddr) {
  120.         if (originaldesc->goMixedModeTrap != _MixedModeMagic) {
  121.             // Trap is 68K
  122.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * 0);
  123.             // allocate new descriptor
  124.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  125.             if (!newdesc) {
  126.                 Debugger();
  127.                 return;
  128.             }
  129.             // set fields of routine decscriptor
  130.             newdesc->goMixedModeTrap = _MixedModeMagic;
  131.             newdesc->version = 7;
  132.             newdesc->routineDescriptorFlags = 0;
  133.             newdesc->reserved1 = 0;
  134.             newdesc->reserved2 = 0;
  135.             newdesc->selectorInfo = 0;
  136.             newdesc->routineCount = 0;
  137.             index = 0;
  138.             gOriginal_MoveWindow = originaldesc;
  139.             newdesc->routineRecords[index].procInfo = upp_MoveWindowProcInfo;
  140.             newdesc->routineRecords[index].reserved1 = 0;
  141.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  142.             newdesc->routineRecords[index].routineFlags = 4;
  143.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_MoveWindowPatch;
  144.             newdesc->routineRecords[index].reserved2 = 0;
  145.             newdesc->routineRecords[index].selector = 0;
  146.         }
  147.         else {
  148.             // Trap is PPC
  149.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * originaldesc->routineCount);
  150.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  151.             if (!newdesc) {
  152.                 DebugStr("\pFailed to allocate RoutineDescriptor");
  153.                 return;
  154.             }
  155.             BlockMoveData(originaldesc, newdesc, size);
  156.             gOriginal_MoveWindow = originaldesc;
  157.             index = 0;
  158.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_MoveWindowPatch;
  159.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  160.         }
  161.         NSetTrapAddress((UniversalProcPtr) newdesc, _MoveWindow, (_MoveWindow & 0x0800) ? ToolTrap : OSTrap);
  162.     }
  163.  
  164.     originaldesc = NGetTrapAddress(_SelectWindow, (_SelectWindow & 0x0800) ? ToolTrap : OSTrap);
  165.     if (originaldesc != unImplimentedTrapAddr) {
  166.         if (originaldesc->goMixedModeTrap != _MixedModeMagic) {
  167.             // Trap is 68K
  168.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * 0);
  169.             // allocate new descriptor
  170.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  171.             if (!newdesc) {
  172.                 Debugger();
  173.                 return;
  174.             }
  175.             // set fields of routine decscriptor
  176.             newdesc->goMixedModeTrap = _MixedModeMagic;
  177.             newdesc->version = 7;
  178.             newdesc->routineDescriptorFlags = 0;
  179.             newdesc->reserved1 = 0;
  180.             newdesc->reserved2 = 0;
  181.             newdesc->selectorInfo = 0;
  182.             newdesc->routineCount = 0;
  183.             index = 0;
  184.             gOriginal_SelectWindow = originaldesc;
  185.             newdesc->routineRecords[index].procInfo = upp_SelectWindowProcInfo;
  186.             newdesc->routineRecords[index].reserved1 = 0;
  187.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  188.             newdesc->routineRecords[index].routineFlags = 4;
  189.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_SelectWindowPatch;
  190.             newdesc->routineRecords[index].reserved2 = 0;
  191.             newdesc->routineRecords[index].selector = 0;
  192.         }
  193.         else {
  194.             // Trap is PPC
  195.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * originaldesc->routineCount);
  196.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  197.             if (!newdesc) {
  198.                 DebugStr("\pFailed to allocate RoutineDescriptor");
  199.                 return;
  200.             }
  201.             BlockMoveData(originaldesc, newdesc, size);
  202.             gOriginal_SelectWindow = originaldesc;
  203.             index = 0;
  204.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_SelectWindowPatch;
  205.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  206.         }
  207.         NSetTrapAddress((UniversalProcPtr) newdesc, _SelectWindow, (_SelectWindow & 0x0800) ? ToolTrap : OSTrap);
  208.     }
  209.     originaldesc = NGetTrapAddress(_SizeWindow, (_SizeWindow & 0x0800) ? ToolTrap : OSTrap);
  210.     if (originaldesc != unImplimentedTrapAddr) {
  211.         if (originaldesc->goMixedModeTrap != _MixedModeMagic) {
  212.             // Trap is 68K
  213.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * 0);
  214.             // allocate new descriptor
  215.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  216.             if (!newdesc) {
  217.                 Debugger();
  218.                 return;
  219.             }
  220.             // set fields of routine decscriptor
  221.             newdesc->goMixedModeTrap = _MixedModeMagic;
  222.             newdesc->version = 7;
  223.             newdesc->routineDescriptorFlags = 0;
  224.             newdesc->reserved1 = 0;
  225.             newdesc->reserved2 = 0;
  226.             newdesc->selectorInfo = 0;
  227.             newdesc->routineCount = 0;
  228.             index = 0;
  229.             gOriginal_SizeWindow = originaldesc;
  230.             newdesc->routineRecords[index].procInfo = upp_SizeWindowProcInfo;
  231.             newdesc->routineRecords[index].reserved1 = 0;
  232.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  233.             newdesc->routineRecords[index].routineFlags = 4;
  234.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_SizeWindowPatch;
  235.             newdesc->routineRecords[index].reserved2 = 0;
  236.             newdesc->routineRecords[index].selector = 0;
  237.         }
  238.         else {
  239.             // Trap is PPC
  240.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * originaldesc->routineCount);
  241.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  242.             if (!newdesc) {
  243.                 DebugStr("\pFailed to allocate RoutineDescriptor");
  244.                 return;
  245.             }
  246.             BlockMoveData(originaldesc, newdesc, size);
  247.             gOriginal_SizeWindow = originaldesc;
  248.             index = 0;
  249.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_SizeWindowPatch;
  250.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  251.         }
  252.         NSetTrapAddress((UniversalProcPtr) newdesc, _SizeWindow, (_SizeWindow & 0x0800) ? ToolTrap : OSTrap);
  253.  
  254.         good = true;
  255.     }
  256.  
  257.     if (good)
  258.     {
  259.         ShowInitIcon(128, true);
  260.         if (theChannel && wHandle)
  261.         {
  262.             anErr = SndPlay(theChannel, (SndListHandle) wHandle, false);
  263.             anErr = SndPlay(theChannel, (SndListHandle) wHandle, false);
  264.             if (noErr != anErr)
  265.                 DebugStr("\p|SndPlay error:?.;");
  266.         }
  267.     }
  268.     else
  269.     {
  270.         ShowInitIcon(129, true);
  271.         if (theChannel && dHandle)
  272.         {
  273.             anErr = SndPlay(theChannel, (SndListHandle) dHandle, false);
  274.             if (noErr != anErr)
  275.                 DebugStr("\p|SndPlay error:?.;");
  276.         }
  277.     }
  278.     // restore to original heap
  279.     SetZone(theZone);
  280.     // restore globals
  281.     ExitCodeResource();
  282. }
  283.  
  284. pascal OSStatus GetWindowBounds(WindowRef window, 
  285.             WindowRegionCode       regionCode,Rect *globalBounds)
  286. {
  287.     OSStatus anErr = noErr;
  288. //    GrafPtr savePort;
  289.     Rect    tRect;
  290.  
  291.     (regionCode);
  292.  
  293. //    GetPort(&savePort);
  294. //    SetPort(window);
  295.  
  296.     tRect = (*((WindowPeek) window)->contRgn)->rgnBBox;
  297.  
  298.     if (nil != globalBounds)
  299.         *globalBounds = tRect;
  300.     else
  301.         anErr = paramErr;
  302.  
  303. //    SetPort(savePort);
  304.  
  305.     return anErr;
  306. }
  307.  
  308. void Swell(Rect * swellee)
  309. {
  310.     swellee->left -= kSwell;
  311.     if (swellee->left < 0)
  312.         swellee->left = 1;
  313.         
  314.     swellee->right += kSwell;
  315.     swellee->top -= kSwell/2;
  316.     if (swellee->top < 0)
  317.         swellee->top = 1;
  318.         
  319.     swellee->bottom += kSwell*2;
  320. }
  321.  
  322. void MoveWindows(void)
  323. {
  324.     WindowPeek baseWindow;
  325.     Rect    wRect = { 20,20,200,820}, mainRect;
  326.     GDHandle tGDHandle = LMGetMainDevice();
  327.     PixMapHandle tPixMapHdl = (*tGDHandle)->gdPMap;
  328.     Rect    sRect = (*tPixMapHdl)->bounds;
  329.     short d1=0;
  330.     unsigned char map[16];
  331.     OSErr anErr = noErr;
  332.  
  333.     GetKeys((unsigned long *)map);
  334.     if(DoKey(56, map))
  335.         return;
  336.     
  337.     if (gInMoveWindows)
  338.         return;
  339.     gInMoveWindows = true;
  340.  
  341.     baseWindow = (WindowPeek) LMGetWindowList();
  342.     if (nil == baseWindow)
  343.     {
  344.         gInMoveWindows = false;
  345.         return;
  346.     }
  347.     
  348. #if 1
  349.     if (nil == theChannel)
  350.     {
  351.     //    DebugStr("\p|Before SndNewChannel-I-Debug;");
  352.         anErr = SndNewChannel(&theChannel, sampledSynth, initStereo, NULL);
  353.         if (noErr != anErr)
  354.             DebugStr("\p|SndNewChannel error:?.;");
  355.     }
  356.  
  357.     if (theChannel && wHandle)
  358.     {
  359.         anErr = SndPlay(theChannel, (SndListHandle) wHandle, false);
  360.     //    anErr = SndPlay(theChannel, (SndListHandle) wHandle, false);
  361.         if (noErr != anErr)
  362.             DebugStr("\p|SndPlay error:?.;");
  363.     }
  364. //    if (theChannel && dHandle)
  365. //        SndPlay(theChannel, (SndListHandle)dHandle, true);
  366. #endif
  367.  
  368.     (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&mainRect);
  369.     Swell(&mainRect);
  370.     
  371.     while (nil != baseWindow)
  372.     {
  373.         Point tDelta;
  374.         short direction=0, whichy = Rand(0,3);
  375.         Rect tRect;
  376.         baseWindow = baseWindow->nextWindow;
  377.         if (nil==baseWindow) 
  378.         {
  379.             gInMoveWindows = false;
  380.             return;
  381.         }
  382.  
  383.         (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&wRect);
  384.  
  385.         while(SectRect(&mainRect, &wRect, nil))
  386.         {
  387.             tDelta.h = tDelta.v = 0;
  388.             switch(whichy)
  389.             {
  390.                 case 0:
  391.                 {
  392.                     switch(direction)
  393.                     {
  394.                         case 0:
  395.                         case 4:
  396.                             tDelta.h=kHOffset;
  397.                             break;
  398.                         case 1:
  399.                         case 5:
  400.                             tDelta.v=-kVOffset;
  401.                             break;
  402.                         case 2:
  403.                         case 6:
  404.                             tDelta.h=-kHOffset;
  405.                             break;
  406.                         case 3:
  407.                         case 7:
  408.                             tDelta.v=kVOffset;
  409.                             break;
  410.                         case 8:
  411.                             tDelta.v=kVOffset;
  412.                             tDelta.h=kHOffset;
  413.                             break;
  414.                     }
  415.                 }
  416.                 break;
  417.             
  418.                 case 1:
  419.                 {
  420.                     switch(direction)
  421.                     {
  422.                         case 0:
  423.                         case 4:
  424.                             tDelta.h=-kHOffset;
  425.                             break;
  426.                         case 1:
  427.                         case 5:
  428.                             tDelta.v=kVOffset;
  429.                             break;
  430.                         case 2:
  431.                         case 6:
  432.                             tDelta.h=kHOffset;
  433.                             break;
  434.                         case 3:
  435.                         case 7:
  436.                             tDelta.v=-kVOffset;
  437.                             break;
  438.                         case 8:
  439.                             tDelta.v=-kVOffset;
  440.                             tDelta.h=-kHOffset;
  441.                             break;
  442.                     }
  443.                 }
  444.                 break;
  445.                 
  446.                 case 2:
  447.                 {
  448.                     switch(direction)
  449.                     {
  450.                         case 0:
  451.                         case 4:
  452.                             tDelta.v=kVOffset;
  453.                             tDelta.h=kHOffset;
  454.                             break;
  455.                         case 1:
  456.                         case 5:
  457.                             tDelta.v=-kVOffset;
  458.                             break;
  459.                         case 2:
  460.                         case 6:
  461.                             tDelta.v=kVOffset;
  462.                             tDelta.h=-kHOffset;
  463.                             break;
  464.                         case 3:
  465.                         case 7:
  466.                             tDelta.v=-kVOffset;
  467.                             break;
  468.                         case 8:
  469.                             tDelta.h=kHOffset;
  470.                             break;
  471.                     }
  472.                 }
  473.                 break;
  474.                 
  475.                 case 3:
  476.                 {
  477.                     switch(direction)
  478.                     {
  479.                         case 0:
  480.                         case 4:
  481.                             tDelta.v=kVOffset;
  482.                             tDelta.h=kHOffset;
  483.                             break;
  484.                         case 1:
  485.                         case 5:
  486.                             tDelta.v=kVOffset;
  487.                             tDelta.h=-kHOffset;
  488.                             break;
  489.                         case 2:
  490.                         case 6:
  491.                             tDelta.v=-kVOffset;
  492.                             tDelta.h=-kHOffset;
  493.                             break;
  494.                         case 3:
  495.                         case 7:
  496.                             tDelta.v=-kVOffset;
  497.                             tDelta.h=kHOffset;
  498.                             break;
  499.                         case 8:
  500.                             tDelta.h=-kHOffset;
  501.                             break;
  502.                     }
  503.                 break;
  504.                 }
  505.                 default:
  506.                     Debugger();
  507.             }
  508. //                tDelta.h += Rand(-3,3);
  509. //                tDelta.v += Rand(-2,2);
  510.                 GetKeys((unsigned long *)map);
  511.                 if(DoKey(56, map))
  512.                 {
  513.                     gInMoveWindows = false;    
  514.                     return;
  515.                 }
  516.             OffsetRect(&wRect,tDelta.h,tDelta.v);
  517.             MoveWindow((WindowPtr)baseWindow, wRect.left, wRect.top, false);
  518. //            CALL_FOUR_PARAMETER_UPP( gOriginal_MoveWindow, upp_MoveWindowProcInfo, (WindowPtr)baseWindow, wRect.left, wRect.top, false);
  519. //                (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&wRect);
  520.  
  521.             SectRect(&sRect, &wRect, &tRect);
  522.             if (!EqualRect(&wRect, &tRect))
  523.             {
  524.                 MoveWindow((WindowPtr)baseWindow, wRect.left - tDelta.h, wRect.top - tDelta.v, false);
  525.                 direction++;
  526.                 (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&wRect);
  527.             }
  528.             if (direction > 8)
  529.                 break;
  530.         }
  531.     }
  532.     gInMoveWindows = false;
  533. }
  534.  
  535. pascal void my_SelectWindowPatch(long param1)
  536. {
  537.     // Get globals
  538.     EnterCodeResource();
  539.  
  540. //    DebugStr("\p|my_SelectWindowPatch-I-Debug;");
  541.  
  542.     CALL_ONE_PARAMETER_UPP( gOriginal_SelectWindow, upp_SelectWindowProcInfo, param1);
  543.     MoveWindows();
  544. //    gInMoveWindows = false;
  545.     // Release globals
  546.     ExitCodeResource();
  547. }
  548.  
  549.  
  550. pascal void my_MoveWindowPatch(long param1, short param2, short param3, Boolean param4)
  551. {
  552.     // Get globals
  553.     EnterCodeResource();
  554.  
  555.     CALL_FOUR_PARAMETER_UPP( gOriginal_MoveWindow, upp_MoveWindowProcInfo, param1, param2, param3, param4);
  556.     MoveWindows();
  557. //    gInMoveWindows = false;
  558.     // Release globals
  559.     ExitCodeResource();
  560. }
  561.  
  562. pascal void my_SizeWindowPatch(long param1, short param2, short param3, Boolean param4)
  563. {
  564.     // Get globals
  565.     EnterCodeResource();
  566.  
  567.     CALL_FOUR_PARAMETER_UPP( gOriginal_SizeWindow, upp_SizeWindowProcInfo, param1, param2, param3, param4);
  568.     MoveWindows();
  569.  
  570.     // Release globals
  571.     ExitCodeResource();
  572. }
  573.  
  574. Boolean DoKey(int k, unsigned char gkm[16])
  575. {
  576.     return((gkm[k>>3]>>(k&7))&1);
  577. }